﻿using EGuayas.Web.Resources;
using EntGuayasSLA.BL;
using EntGuayasSLA.BL.Archivos.Pdf;
using EntGuayasSLA.BL.Listas;
using EntGuayasSLA.BL.Listas.Criterias;
using Ext.Net;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace EGuayas.Web.Auditoria.promotor
{
    public partial class wucLoadDoc : ucWuc
    { 
        /// <summary>
        /// Id adicional utilizado solamente en auditoria otros
        /// </summary>
        protected string IdAdd
        {
            get
            {
               string strValReturn= this.hddIdAdd.Value.ToString();
               //Obtener el valor en el caso que se asigne el valor con metodo EnabledBtnNuevoDocumento(string idAdd,Boolean setHiden,Boolean valHiden)
               //caso contrario
               if (strValReturn=="")
               {
                   strValReturn=GetSessionPage.GetSession(FaseOrAuditoriaId);
               }
               return strValReturn;
            }
           
        }
        protected String FaseId
        {
            get
            {

                return ReadCustomConfigFase(this.pnlLoadDocumentos, this.ID);
            }

        }
        /// <summary>
        /// Obtener fase id seteada en evento <OnComponentAdded> del user control
        /// </summary>
        protected String FaseOrAuditoriaId
        {
            get
            {
                return ReadCustomConfigFaseAuditoria(this.pnlLoadDocumentos, this.ID);
            }

        }
        /// <summary>
        /// Obtener fase id seteada en evento <OnComponentAdded> del user control
        /// </summary>
        protected String FaseCumplId
        {
            get
            {
                return ReadCustomConfigFaseAuditoria(this.pnlLoadDocumentos, this.ID);
            }

        }
        protected String TablaAud
        {
            get
            {

                return ReadCustomConfig(this.pnlLoadDocumentos, this.ID, "_aud");
            }

        }
        protected String PageId
        {
            get
            {
                
                return ReadCustomConfigPage(this.pnlLoadDocumentos, this.ID);
            }

        }
        /// <summary>
        /// Lista de documentos de requisitos segun fase de licenciamiento
        /// </summary>
        protected RequisitoFaseLista RequisitosFase
        {
            get
            {
                if (Session["wucLoadDocListaRequisitas1"+this.ID] == null)
                {
                    Session["wucLoadDocListaRequisitas1" + this.ID] = new RequisitoFaseLista();
                }
                return ((RequisitoFaseLista)Session["wucLoadDocListaRequisitas1" + this.ID]);
            }
            set
            {
                Session["wucLoadDocListaRequisitas1" + this.ID] = value;
            }
        }
        protected string RequisitoOtroId
        {
            get
            {
                if (Session["wucLoadDocReqOtro" + this.ID] == null)
                {
                    Session["wucLoadDocReqOtro" + this.ID] = "";
                }
                return (Session["wucLoadDocReqOtro" + this.ID].ToString());
            }
            set
            {
                Session["wucLoadDocReqOtro" + this.ID] = value;
            }
        }
        protected String EstadoFase
        {
            get
            {

                return ReadCustomConfigEstadoFase(this.pnlLoadDocumentos, this.ID);
            }

        }
        protected void Page_Load(object sender, EventArgs e)
        {
         try
         {
            if (!X.IsAjaxRequest)
            {

               this.WucInit();
            }
         }
         catch (Exception ex)
         {
             RegistrarLog("wucLoadDoc.Page_Load" + ex);
         }
        }

        private void WucInit()
        {
          try
          {
              var FaseIdval = GetSessionPage.GetSession(FaseOrAuditoriaId);
              if (FaseIdval != "")
              {
                  var FaseIdGlobalVal = (TablaAud == Valores.Modulo_Archivo_Aud_Otros) ? IdAdd : GetSessionPage.GetSession(FaseOrAuditoriaId);

                  DataBindRequisitos(GetSessionPage.GetSession(FaseId), FaseIdGlobalVal);
                  //TODO: aqui hay que colocar la opcion del estado del proceso si no es Apropbado o Aprobado con observacion 
                  //TODO:se posibilita para que envie nuevamente la doc y le debe llegar a la subdirectora
                  //VALIDAR HABILITAR BOTON <ENVIO>
                  if (GetSessionPage.GetSession(EstadoFase) == Valores.Codigo_Estado_Fase_Inicial)
                  {
                      this.btnValidarDocumentos.Enable();
                  }
                  else
                  {
                      
                      //MODO LECTURA
                     if (GetSessionPage.GetSession(EstadoFase) == Valores.Codigo_Estado_Fase_Finalizado)
                     {
                         this.btnValidarDocumentos.Disable();
                          int index = this.gpDocumentosLoad.ColumnModel.Columns.Count;
                          //No vizualizar las ultimas 2 columnas
                          for (int i = 2; i > 0; i = i - 1)
                          {
                              index -= 1;
                              this.gpDocumentosLoad.RemoveColumn(index);
                          }
                      }
                  }
                  if (this.btnForm.Visible)
                  {
                        this.btnForm.Enable();
                  }
                }
                else 
                {
                    if (this.btnForm.Visible)
                        this.btnForm.Disable();            
                }
            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.WucInit" + ex);
            }
           
        }

        private void DataBindRequisitos(string FaseIdval, string FaseIdGlobalVal)
        {
            try
            {
               
                //Obtener requisitos obligatorio
                RequisitoCriteriaObligatorio criteria = RequisitoCriteriaObligatorio.NewRequisitoCriteriaObligatorio();
                criteria.Codigo = this.ReadCustomConfigCodeFase(this.pnlLoadDocumentos, this.ID);
                criteria.Obligatorio = Valores.Codigo_CHAR_Si;
                RequisitoFaseLista RequisitosFaseObliga = RequisitoFaseLista.GetRequisitoFaseLista(criteria);

                RequisitoCriteriaObligatorio criteriaRequisitos = RequisitoCriteriaObligatorio.NewRequisitoCriteriaObligatorio();
                criteriaRequisitos.Codigo = this.ReadCustomConfigCodeFase(this.pnlLoadDocumentos, this.ID);
                criteriaRequisitos.IdAdd = FaseIdGlobalVal;
                RequisitosFase = RequisitoFaseLista.GetRequisitoFaseLista(criteriaRequisitos);

                foreach (RequisitoFaseInfo rqFase in RequisitosFase)
                {
                    //Agregar requisitos obligatorios de documentos otros no existentes
                    RequisitoFaseInfo rqFaseSeek = RequisitosFaseObliga.FirstOrDefault(r => r.Id == rqFase.Id);
                    if (rqFase.Obligatorio == Valores.Codigo_CHAR_Si && rqFaseSeek == null)
                    {
                        RequisitosFaseObliga.Add(rqFase);
                    }

                }
                stoReqOblig.DataSource = RequisitosFaseObliga;
                stoReqOblig.DataBind();

                //Obtener <ID> requisitos <otros> 
                RequisitoFaseInfo infoItem = RequisitosFase.FirstOrDefault(r => r.Nombre == Valores.Nombre_DocFase);
                if (infoItem != null)
                {
                    RequisitoOtroId = infoItem.Id.ToString();
                }
                else
                {
                    RequisitoOtroId = "";
                }
                //Asignar al store para nuevas versiones          
                stoTipoVersion.DataSource = RequisitosFase;
                stoTipoVersion.DataBind();
                //Quitar de lixbox item subidos 
                RequisitoFaseLista itemsLoadCbx = RequisitosFase.Clone();
                ArchivoGlobalCriteria filter = ArchivoGlobalCriteria.NewArchivoGlobalCriteria();
                filter.ExpedienteId = GetSessionPage.ExpedienteId(PageId);
                filter.FaseId = FaseIdGlobalVal;
                filter.Tabla = TablaAud;
                ArchivoLista itemLoad = ArchivoLista.GetArchivoLista(filter);
                foreach (ArchivoInfo seek in itemLoad)
                {

                    RequisitoFaseInfo item = itemsLoadCbx.FirstOrDefault(r => r.Id.ToString() == seek.TipoDocumento);
                    if (item != null && item.Id.ToString() != RequisitoOtroId)
                    {
                        itemsLoadCbx.Remove(item);
                    }
                }
                //
                stoTipo.DataSource = itemsLoadCbx;
                stoTipo.DataBind();
            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.DataBindRequisitos" + ex);
            }
        }
        /// <summary>
        /// Habilitar boton
        /// </summary>
        /// <param name="idAdd">Identificador adicional </param>
        /// <param name="setHiden">Habilitar la propiedad "Ocultar" boton</param>
        /// <param name="valHiden">Show/Hide</param>
        public void EnabledBtnNuevoDocumento(string idAdd,Boolean setHiden,Boolean valHiden)
        {
         try
         {
            if (setHiden)
            {
                if (valHiden)
                    this.btnForm.Show();
                else
                    this.btnForm.Hide();
            }
            this.hddIdAdd.SetValue(idAdd);
            WucInit();
         }
         catch (Exception ex)
         {
             RegistrarLog("wucLoadDoc.EnabledBtnNuevoDocumento" + ex);
         }
        }
        /// <summary>
        /// Datos de archivos de promotor
        /// </summary>
        /// <returns></returns>
        [DirectMethod(IDAlias = "WucAudLoadDocAud")]
        public ArchivoLista BindData()
        {
            try
            {
            ArchivoGlobalCriteria filter = ArchivoGlobalCriteria.NewArchivoGlobalCriteria();
            filter.ExpedienteId = GetSessionPage.ExpedienteId(PageId);
            filter.FaseId = (TablaAud == Valores.Modulo_Archivo_Aud_Otros) ? IdAdd : GetSessionPage.GetSession(FaseOrAuditoriaId);
            filter.Tabla = TablaAud;
            return ArchivoLista.GetArchivoLista(filter);
            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.BindData" + ex);
            }
            return null;
        }
        #region Expander Grid
        protected static void GrdInbox_Command(object sender, DirectEventArgs e)
        {
           
        }
       
        #endregion Expander Grid

        /// <summary>
        /// Subir archivos de promotor
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void UploadClick(object sender, DirectEventArgs e)
        {
            try
            {
                FileUploadField myCtlFileUp = (FileUploadField)this.FindControl("FileUploadDocUp");
                if (myCtlFileUp.HasFile)
                {
                    Boolean IfNewVer = Convert.ToBoolean(e.ExtraParams["hddnDocIfVer"]);
                    int version = 0;
                    string fileExt = myCtlFileUp.PostedFile.FileName.Substring(myCtlFileUp.PostedFile.FileName.LastIndexOf('.') + 1);
                    string ruta = "";
                    string fileName = "";
                    string fileNameTmp = "";

                    Int32.TryParse(e.ExtraParams["hddnDocUpVers"], out version);
                    this.GetNameFile(myCtlFileUp, fileExt, ref ruta, ref fileName, ref fileNameTmp);


                    byte[] USER = Encoding.UTF8.GetBytes(ConfigurationManager.AppSettings.Get("UserPdf"));
                    byte[] OWNER = Encoding.UTF8.GetBytes(ConfigurationManager.AppSettings.Get("PwdPdf"));

                    if (fileExt.ToLower() == "pdf")
                    {
                        myCtlFileUp.PostedFile.SaveAs(fileNameTmp);
                        Pdf.EncryptFilePdf(fileNameTmp, fileName, USER, OWNER);
                        File.Delete(fileNameTmp);
                    }
                    else
                    {
                        myCtlFileUp.PostedFile.SaveAs(fileName);
                    }
                    string tpl = Mensajes.MensajeArchivoCorrecto;

                    Archivo objArch = Archivo.NewEditableRoot(TablaAud);
                    objArch.Id = System.Guid.NewGuid();
                    //Nuevas versiones datos correguidos
                    objArch.SubirNuevo = "C";
                    if (version == 1)
                    {
                        objArch.SubirNuevo = "N";
                        objArch.Referencia = objArch.Id.ToString();
                        //tipo de documento en nuevas versionas check
                        objArch.TipoDocumento = e.ExtraParams["cbxTipo"];
                    }
                    else
                    {
                        Archivo objArchAnterior = null;
                        if (version == 2)
                        {
                            objArch.Referencia = e.ExtraParams["hddnDocUpId"];
                            objArchAnterior = Archivo.GetEditableRoot(Guid.Parse(objArch.Referencia), Valores.Modulo_Archivo_Licenciamiento);
                            objArch.TipoDocumento = objArchAnterior.TipoDocumento;
                        }
                        else
                        {
                            if (version > 2)
                            {
                                objArch.Referencia = e.ExtraParams["hddnDocUpRef"];
                                objArchAnterior = Archivo.GetEditableRoot(Guid.Parse(objArch.Referencia), Valores.Modulo_Archivo_Licenciamiento);
                                objArch.TipoDocumento = objArchAnterior.TipoDocumento;
                            }
                        }
                    }
                    objArch.Nombre = e.ExtraParams["txtNombre"];
                    objArch.Descripcion = e.ExtraParams["txtDesp"];
                    objArch.FechaCreacion = DateTime.Now;
                    objArch.RequiereFirmar = "N";
                    objArch.Firmado = "N";
                  

                    objArch.Version = version;
                    objArch.RequiereFirmar = "N";

                    objArch.PersonaId = GetSessionUsuario.PersonaId;
                    objArch.GlobalRelacionId    = GetSessionPage.GetSession(FaseOrAuditoriaId);
                    objArch.IdAdd     = IdAdd;
                    objArch.ExpedienteId = GetSessionPage.ExpedienteId(PageId);
                    objArch.Ruta = ruta;

                    objArch.Save();

                    
                    //cbxTipo.GetStore().JsonData.Length;
                    //Guardar id archivos temporalmente recien creados
                    ExtNet.Js.Call("wucJsLoadDoc.AddIdsNew", objArch.Id.ToString(), objArch.Version.ToString());
                    gpDocumentosLoad.GetStore().Reload();
                    X.Msg.Show(new MessageBoxConfig
                    {
                        Buttons = MessageBox.Button.OK,
                        Icon = MessageBox.Icon.INFO,
                        Title = Titulos.TituloAviso,
                        Message = string.Format(tpl, myCtlFileUp.PostedFile.FileName)
                    });
                    winDocumento.Hide();
                    //Validacion de tipo de documento, eliminar del store item seleccionado.
                    if (RequisitoOtroId != objArch.TipoDocumento)
                    {
                        var recordRequisito = cbxTipo.GetStore().Find("Id", objArch.TipoDocumento);

                        if (recordRequisito != null)
                        {
                            //Valores.Codigo_Fase

                            cbxTipo.GetStore().Remove(recordRequisito);
                        }
                    }
                }
                else
                {
                    winDocumento.Hide();
                    X.Msg.Show(new MessageBoxConfig
                    {
                        Buttons = MessageBox.Button.OK,
                        Icon    = MessageBox.Icon.ERROR,
                        Title = Titulos.TituloAviso,
                        Message = Mensajes.MensajeArchivoIncorrecto
                    });

                }
               
            }
            catch (Exception ex)
            {
                winDocumento.Hide();
                RegistrarLog("wucLoadDoc.UploadClick" + ex);
                X.Msg.Show(new MessageBoxConfig
                {
                    Buttons = MessageBox.Button.OK,
                    Icon    = MessageBox.Icon.ERROR,
                    Title = Titulos.TituloAviso,
                    Message = Mensajes.MensajeArchivoIncorrecto
                });
            }
        }
        /// <summary>
        /// Validar numero de documentos obligatorios
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void ValidarClick(object sender, DirectEventArgs e)
        {
            try
            {
                string ValFaseId = (TablaAud == Valores.Modulo_Archivo_Aud_Otros) ? IdAdd : GetSessionPage.GetSession(FaseOrAuditoriaId);
                string estadoFase="";
                switch (TablaAud)
                {
                    case Valores.Modulo_Archivo_Aud_Otros:
                        var objAudOtros = AuditoriaOtros.GetEditableRoot(Guid.Parse(ValFaseId));
                        estadoFase = objAudOtros.EstadoFase;
                        CrearProcesoRecepcion(estadoFase, ValFaseId, Valores.Modulo_Archivo_Aud_Otros);
                        objAudOtros.EstadoFase = Valores.Codigo_Estado_Fase_Proceso;
                        objAudOtros.Save();
                        break;
                    case Valores.Modulo_Archivo_Aud_Cump:
                        var objFaseAudCum = FaseAuditoria.GetEditableRoot(Guid.Parse(ValFaseId));
                        estadoFase = objFaseAudCum.EstadoFase;
                        CrearProcesoRecepcion(estadoFase, ValFaseId, Valores.Modulo_Archivo_Aud_Cump);
                        objFaseAudCum.EstadoFase = Valores.Codigo_Estado_Fase_Proceso;
                        objFaseAudCum.Save();
                        break;
                    case Valores.Modulo_Archivo_Aud_Moni:
                        var objFaseAudMon = AuditoriaMonitoreo.GetEditableRoot(Guid.Parse(ValFaseId));
                        estadoFase = objFaseAudMon.EstadoFase;
                        CrearProcesoRecepcion(estadoFase, ValFaseId, Valores.Modulo_Archivo_Aud_Moni);
                        objFaseAudMon.EstadoFase = Valores.Codigo_Estado_Fase_Proceso;
                        objFaseAudMon.Save();
                        break;
                    case Valores.Modulo_Archivo_Aud_Pma:
                        var objFaseAudPma = AuditoriaPMA.GetEditableRoot(Guid.Parse(ValFaseId));
                        estadoFase = objFaseAudPma.EstadoFase;
                        CrearProcesoRecepcion(estadoFase, ValFaseId, Valores.Modulo_Archivo_Aud_Pma);
                        objFaseAudPma.EstadoFase = Valores.Codigo_Estado_Fase_Proceso;
                        objFaseAudPma.Save();
                        break;
                }

                
                //if (objEstadoFase.FaseLicId == "")
                //{
                //    objEstadoFase = EstadoFaseLicenciamiento.NewEditableRoot();
                //    objEstadoFase.Id = System.Guid.NewGuid();
                //    objEstadoFase.FaseLicId = ValFaseId;
                //    objEstadoFase.FechaEFL = DateTime.Now;
                //    objEstadoFase.EstadoFase = Valores.Codigo_Estado_Fase_Proceso;
                //    objEstadoFase.Save();
                    

                //}
                //else
                //{
                //    objEstadoFase.EstadoFase = Valores.Codigo_Estado_Fase_Proceso;
                //    objEstadoFase.Save();
                //}
                //No vizualizar opciones eliminar en caso de validar
                RemoveEndColumnGridGlobal(4, this.gpDocumentosLoad);
                //Presentar mensaje y no vizualizar opcion eliminar de grid
                X.Msg.Show(new MessageBoxConfig() { Message = Mensajes.MensajeDocumentoEnvia, Title = Titulos.TituloAviso, 
                    Buttons = MessageBox.Button.OK, Icon = MessageBox.Icon.INFO,
                    Handler = "wucJsLoadDoc.ClearIdsNew()"
                });
                this.btnValidarDocumentos.Disable();
                
            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.ValidarClick" + ex);
            }

        }

        private void CrearProcesoRecepcion(string estadoFase, string ValFaseId, string tabla)
        {
            try
            {
                if (estadoFase == Valores.Codigo_Estado_Fase_Inicial)
                {
                    RecepcionProceso objRecep = RecepcionProceso.NewEditableRoot();
                    objRecep.Id = System.Guid.NewGuid();
                    objRecep.ExpedienteId = GetSessionPage.ExpedienteId(PageId);
                    objRecep.CodigoFase = ReadCustomConfigCodeFase(this.pnlLoadDocumentos, this.ID);
                    objRecep.Tabla = tabla;
                    objRecep.IdTabla = ValFaseId;
                    objRecep.Jefatura = Constantes.Auditoria;
                    objRecep.Save();
                }

            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.CrearProcesoRecepcion" + ex);
            }

        }
        /// <summary>
        /// Eliminar archivos de promotor
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>     
        protected void btnDocUpEliminar_Click(object sender, DirectEventArgs e)
        {
            try
            {
                var id = Guid.Parse(e.ExtraParams["hddArchDelId"]);
                Archivo objArch = Archivo.GetEditableRoot(id, TablaAud);

                DeleteFile(objArch.Ruta);

                //var dataFile = ArchivoLista.GetArchivoLista(id);
                //foreach (var item in dataFile)
                //    DeleteFile(item.Ruta);

                objArch.Delete();
                objArch.Save();

                gpDocumentosLoad.GetStore().Reload();

                //Validacion de tipo de documento, eliminar del store item seleccionado.
                //Diferente de item otro, quitar de la lista de tipo de documentos
                if (RequisitoOtroId != objArch.TipoDocumento)
                {
                    Guid idTipoDocumento = Guid.Parse(objArch.TipoDocumento);
                    var itemAdd = RequisitosFase.FirstOrDefault(r => r.Id == idTipoDocumento);
                    if (itemAdd != null)
                    {
                        cbxTipo.GetStore().Add(new
                        {
                            Id = itemAdd.Id,
                            Nombre = itemAdd.Nombre,
                            Obligatorio = itemAdd.Obligatorio,
                            Formato = itemAdd.Formato
                        });

                    }
                }
            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.btnDocUpEliminar_Click" + ex);
            }

        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="file"></param>
        private void DeleteFile(string file)
        {
            try
            {
            var path = Server.MapPath(file);
            if (System.IO.File.Exists(path))
                File.Delete(path);
            }
            catch (Exception ex)
            {
                RegistrarLog("wucLoadDoc.DeleteFile" + ex);
            }
        }
    
    
    
    }
}